package com.aaa.dang.modules.system.service.impl;

import com.aaa.dang.common.entity.Permission;
import com.aaa.dang.common.systemlog.annotation.SysLog;
import com.aaa.dang.common.util.ResultModel;
import com.aaa.dang.modules.system.dao.IPermissionDao;
import com.aaa.dang.modules.system.service.IPermissionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

import static com.aaa.dang.common.systemconst.ISystemConst.FAULT_CODE;
import static com.aaa.dang.common.systemconst.ISystemConst.SUCCESS_CODE;

/**
 * 权限管理业务实现
 *
 * @author Dadazhao
 * @date 2018/12/18
 */
@Service
public class PermissionServiceImpl implements IPermissionService {

    /**
     * 注入权限
     */
    @Autowired
    private IPermissionDao permissionDao;
    @Autowired
    ResultModel model;

    /**
     * 查询所有的权限
     *
     * @param status 空为所有 0为正常 1为停用
     * @return 权限列表
     */
    @Override
    public ResultModel getPermissionAll(Integer status) {
        //查询所有的权限
        model.setCode(0);
        model.setMsg("查询成功");
        model.setData(permissionDao.getPermissionAll(status));
        return model;
    }

    /**
     * 修改权限的状态
     *
     * @param id     权限id
     * @param status 状态 0 为启用 1 为禁用
     * @return code 0 成功 1 失败
     */
    @Override
    @SysLog(operateType = SysLog.Type.UPDATE, desc = "修改权限的状态")
    public ResultModel updatePermissionStatus(Integer id, Integer status) {
        int count = permissionDao.updatePermissionStatus(id, status);
        //影响行数
        if (count > 0) {
            model.setCode(SUCCESS_CODE);
            model.setMsg("变更成功");
            model.setData("");
        } else {
            model.setCode(FAULT_CODE);
            model.setMsg("变更失败");
            model.setData("");
        }
        return model;
    }

    /**
     * 添加新的权限或功能
     *
     * @param permi 权限实体
     * @return code 0 成功 1 失败
     */
    @Override
    @SysLog(operateType = SysLog.Type.ADD, desc = "添加新的权限或功能")
    public ResultModel addPermission(Permission permi) {
        int count = permissionDao.addPermission(permi);
        //影响行数
        if (count > 0) {
            model.setCode(SUCCESS_CODE);
            model.setMsg("添加成功");
            model.setData("");
        } else {
            model.setCode(FAULT_CODE);
            model.setMsg("添加失败");
            model.setData("");
        }
        return model;
    }

    /**
     * 修改权限
     *
     * @param permi 权限实体
     * @return code 0 成功 1 失败
     */
    @Override
    @SysLog(operateType = SysLog.Type.UPDATE, desc = "修改权限信息")
    public ResultModel updatePermissionById(Permission permi) {
        int count = permissionDao.updatePermissionById(permi);
        model.setCode(SUCCESS_CODE);
        model.setMsg("修改成功");
        model.setData("");
        return model;
    }

    /**
     * 通过ID删除权限
     *
     * @param id 权限id
     * @return code 0 成功 1 失败
     */
    @Override
    @SysLog(operateType = SysLog.Type.DELETE, desc = "删除权限")
    public ResultModel deletePermissionById(Integer id) {
        //查看出父目录为id的权限
        //定义权限状态 为空时查询所有
        Integer status = null;
        List<Map<String, Object>> pList = permissionDao.getChildPermissionById(id, status);
        if (pList.size() > 0) {
            model.setCode(FAULT_CODE);
            model.setMsg("删除失败");
            model.setData("");
            return model;
        }
        //通过id删除权限数据 获得影响的行数
        int pCount = permissionDao.deletePermissionById(id);
        //删除角色权限表有关权限的数据
        int rpCount = permissionDao.deleteRolePermissionByPermissionId(id);
        if (pCount > 0) {
            model.setCode(SUCCESS_CODE);
            model.setMsg("删除成功");
            model.setData("");
            return model;
        }
        return model;
    }

    /**
     * 获得Tree格式的所有权限
     *
     * @param status 状态 空为所有 0为正常 1 为禁用（不推荐）
     * @return 权限 tree
     */
    @Override
    public ResultModel getPermissionTreeAll(Integer status) {
        //先获得所有
        List<Map<String, Object>> permissionAll = permissionDao.getPermissionAll(status);
        List<Map<String, Object>> perList = recursion(permissionAll);
        model.setCode(0);
        model.setData(perList);
        model.setMsg("查询成功");
        return model;
    }

    /**
     * 通过角色Id获得角色权限
     *
     * @param id 角色id
     * @return 拥有的权限列表
     */
    @Override
    public ResultModel getRolePermissionById(Integer id) {
        model.setCode(SUCCESS_CODE);
        model.setMsg("查询成功");
        model.setData(permissionDao.getRolePermissionById(id));
        return model;
    }

    /**
     * 通过员工id获得拥有的权限
     *
     * @param id 员工id
     * @return 拥有的权限列表
     */
    @Override
    public ResultModel getHavePermissionById(Integer id) {
        model.setCode(SUCCESS_CODE);
        model.setMsg("查询成功");
        model.setData(permissionDao.getHavePermissionById(id));
        return model;
    }

    /**
     * 递归添加权限 tree
     *
     * @param cMap          权限
     * @param permissionAll 所有的权限
     */
    private void recursion(Map cMap, List<Map<String, Object>> permissionAll) {
        //存储子权限
        List<Map<String, Object>> cList = new ArrayList<>();
        //判断有没有子权限
        for (Map<String, Object> ccMap : permissionAll) {
            //有
            if (cMap.get("id") == null) {
                return;
            }
            if (cMap.get("id").equals(ccMap.get("pid"))) {
                //递归
                recursion(ccMap, permissionAll);
                cList.add(ccMap);
                cMap.put("child", cList);
            }
        }
    }

    private List<Map<String, Object>> recursion(List<Map<String, Object>> permissionAll) {
        //所有的map添加child
        List<Map<String, Object>> list = new ArrayList<>();
        for (Map<String, Object> permissionMap : permissionAll) {
            permissionMap.put("child", list);
        }
        //存储所有权限
        List<Map<String, Object>> pList = new ArrayList<>();
        //遍历所有权限
        for (Map<String, Object> pMap : permissionAll) {
            //获取类型
            String permiType = String.valueOf(pMap.get("permiType"));
            //判断是不是菜单
            if ("0".equals(permiType)) {
                //进入递归
                recursion(pMap, permissionAll);
                pList.add(pMap);
            }
        }
        return pList;
    }

    /**
     * 通过角色id获得拥有的权限(树形)
     *
     * @param id 角色id
     * @return 权限 tree类型
     */
    @Override
    public ResultModel getHavePermissionTreeById(Integer id) {
        //先获得拥有所有
        List<Map<String, Object>> permissionAll = permissionDao.getHavePermissionById(id);
        //进行递归
        List<Map<String, Object>> pList = recursion(permissionAll);
        model.setMsg("查询成功");
        model.setData(pList);
        model.setCode(0);
        return model;
    }


    /**
     * 通过角色登录名称获得角色权限
     *
     * @param empLoginName 登录账号
     * @return 权限列表
     */
    @Override
    public Set<String> getPermissionsByEmpLoginName(String empLoginName) {
        List<Map<String, Object>> permissions = null;
        if (empLoginName == null) {
            //获得所有权限
            permissions = permissionDao.getPermissionAll(null);
        } else {
            //获得拥有的权限
            permissions = permissionDao.getHavePermissionByEmpLoginName(empLoginName);
        }
        //存储权限
        HashSet<String> permis = new HashSet<>();
        //遍历得到的权限
        for (Map<String, Object> permission : permissions) {
            String permiName = String.valueOf(permission.get("permiName"));
            if (!"null".equals(permiName) && !"".equals(permiName)) {
                //将权限名（）存入集合
                permis.add(permiName);
            }
        }
        return permis;
    }
}
